/*
 * test_capture_fallback.c - Test capture backend fallback chain
 * 
 * Validates:
 * - DRM initialization and frame capture (if available)
 * - X11 fallback when DRM unavailable
 * - Dummy fallback when both unavailable
 * - Proper error handling and cleanup
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "../common/test_harness.h"

typedef struct {
    const char *name;
    int (*init_fn)(rootstream_ctx_t *ctx);
    int (*capture_fn)(rootstream_ctx_t *ctx, frame_buffer_t *frame);
    void (*cleanup_fn)(rootstream_ctx_t *ctx);
} capture_backend_t;

/* Mock DRM backend for testing */
int mock_drm_init(rootstream_ctx_t *ctx) {
    ctx->current_frame.width = 1920;
    ctx->current_frame.height = 1080;
    ctx->current_frame.format = 0x34325258;  /* XRGB8888 */
    return 0;
}

int mock_drm_capture(rootstream_ctx_t *ctx, frame_buffer_t *frame) {
    /* Generate test pattern */
    memset(frame->data, 0x80, frame->capacity);  /* Gray */
    frame->size = ctx->current_frame.width * ctx->current_frame.height * 4;
    return 0;
}

void mock_drm_cleanup(rootstream_ctx_t *ctx) {
    (void)ctx;
}

/* Test: DRM capture initialization */
test_result_t test_capture_drm_init(void) {
    rootstream_ctx_t ctx = {0};
    
    int ret = mock_drm_init(&ctx);
    assert(ret == 0);
    assert(ctx.current_frame.width == 1920);
    assert(ctx.current_frame.height == 1080);
    
    mock_drm_cleanup(&ctx);
    return TEST_PASS;
}

/* Test: DRM capture frame */
test_result_t test_capture_drm_frame(void) {
    rootstream_ctx_t ctx = {0};
    frame_buffer_t frame = {0};
    uint8_t buffer[1920 * 1080 * 4];
    
    mock_drm_init(&ctx);
    frame.data = buffer;
    frame.capacity = sizeof(buffer);
    
    int ret = mock_drm_capture(&ctx, &frame);
    assert(ret == 0);
    assert(frame.size > 0);
    
    mock_drm_cleanup(&ctx);
    return TEST_PASS;
}

/* Test: Fallback selection - try all backends */
test_result_t test_capture_fallback_chain(void) {
    rootstream_ctx_t ctx = {0};
    
    const capture_backend_t backends[] = {
        { "DRM", mock_drm_init, mock_drm_capture, mock_drm_cleanup },
        /* X11 would be tested here if available */
        /* Dummy would be tested here */
        {NULL}
    };
    
    /* Try each backend */
    for (int i = 0; backends[i].name; i++) {
        int ret = backends[i].init_fn(&ctx);
        
        if (ret == 0) {
            /* Backend initialized successfully */
            frame_buffer_t frame = {0};
            uint8_t buffer[1920 * 1080 * 4];
            frame.data = buffer;
            frame.capacity = sizeof(buffer);
            
            ret = backends[i].capture_fn(&ctx, &frame);
            assert(ret == 0...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

*This pull request was created from Copilot chat.*
>

<!-- START COPILOT CODING AGENT TIPS -->
---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more [Copilot coding agent tips](https://gh.io/copilot-coding-agent-tips) in the docs.